Discussion: I honestly have no idea what this test is actually trying to exercise. This goes all the way back to 2010 d6b7c96.

I assume this is trying to exercise some short-circuiting behavior of || and && but the test itself makes it hard to tell.

EDIT: the OG version of this Rust was

fn incr(mutable &int x) -> bool {
  x += 1;
  check (false);
  ret false;
}

fn main() {

  auto x = (1 == 2) || (3 == 3);
  check (x);

  let int y = 10;
  log x || incr(y);
  check (y == 10);

  if (true && x) {
    check (true);
  } else {
    check (false);
  }

}

so yeah, I believe this is indeed a || and && short-circuiting test. It has a no-arg closure, presumably because back then there must've been a case where the parser confused || and the no-arg closure form || EXPR or sth.

What's amusing is that this is one of the listings of the archive of OG rust syntax listed at https://brson.github.io/archaea/lazy-and-or.html/.

EDIT: I realized you can actually see the dynamic evolution of this test on that listing!

Thanks for the analysis and sharing that interesting link! Now I understand that this test verifies short-circuiting behavior of logical operators.

I'll update the test with clearer naming and comments to better express its purpose while preserving the original functionality.

And thanks for the historical context! That's super helpful 😁

Discussion: so this one is also introduced in the 2010 populate tree commit, and it kinda has been preserved all these years modulo some language changes. I believe this is some kind of "positive" smoke test of a tree of owned memory...?

Originally (like back in Rust 0.8), this was

tag list {
  cons(int,@list);
  nil;
}

fn main() {
  cons(10, @cons(11, @cons(12, @nil)));
}

This is also one of the OG rust syntax examples at https://brson.github.io/archaea/list.html.

Remark: yeah, this test is because unary negation on an owned string didn't use to properly typeck, back in de4b383.